﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.IO;

namespace Maestro_Proveedores.herramientas
{
    /// <remarks>
    /// Esta encapsula todas las operaciones que se deben realizar para manipular archivos, 
    /// permititiemdo realizar conversiones de byte a files o viceversa. Tambien permite realizar operaciones
    /// como copiar archivos desde un directorio a otro en el disco duro.
    /// </remarks>
    public class File
    {
        /// <summary>
        /// <para>Crear un nuevo un archivo (APARTIR DE UN ARCHIVO EXISTENTE) en un directorio.<br/> Al nuevo archivo se le coloca un nombre compuesto por un numero aleatorio y la fechaHora de creacion.</para>
        /// <para>El principal uso de este metodo es subir archivos a la carpeta de archivos de soporte.</para>
        /// </summary>
        /// <param name="archivoOriginal">Ruta completa del archivo que se va a amover a la carpeta de archivos eliminados.</param>
        /// <returns></returns>
        public static bool moveFileToReciclerDirectory(string archivoOriginal)
        {
            try
            {
                //--- el ultimo registro de este vector tendra el nombre completo del archivo (con extension)
                string[] v = archivoOriginal.Split('/');
                string archivoDestino = ConfiguracionDelSistema.directorioArchivosEliminados + v[v.Length-1].Replace(".", "(" + DateTime.Now.ToShortDateString().Replace("/", "-") + "__" + Session.Seg_USUARRow.USUARIO + ").");
                System.IO.File.Move(archivoOriginal,archivoDestino);
            }
            catch (Exception ex)
            {
                herramientas.MessageException.show(ex);
                return false;
            }
            return true;
        }

        /// <summary>
        /// <para>Crear un nuevo un archivo (APARTIR DE UN ARCHIVO EXISTENTE) en un directorio.<br/> Al nuevo archivo se le coloca un nombre compuesto por un numero aleatorio y la fechaHora de creacion.</para>
        /// <para>El principal uso de este metodo es subir archivos a la carpeta de archivos de soporte.</para>
        /// </summary>
        /// <param name="archivoOriginal">Ruta completa del archivo en base al cual se desea crear el nuevo archivo.</param>
        /// <param name="directorioDestino">Directorio en el cual se creara el nuevo archivo.</param>
        /// <returns>
        /// <para>Nombre completo del nuevo archivo (incluye la extension del nuevo archivo)</para>
        /// <para>En caso de que la operacion no se realice de forma correcta retorna un string vacio (string.Empty)</para>
        /// </returns>
        public static string newFile(string archivoOriginal, string directorioDestino)
        {
            string nuevoArchivo = string.Empty;
            try
            {                   
                //--definir la extension del nuevo archivo.
                string[] temp = archivoOriginal.Split('.');
                //-- definir el nombre del nuevo archivo (UNICO)
                nuevoArchivo = (new Random().Next(0, 1000)) + "" + (DateTime.Now.Year) + "" + (DateTime.Now.Month) + "" + (DateTime.Now.Day) + "" + (DateTime.Now.Hour) + "" + (DateTime.Now.Minute) + "" + (DateTime.Now.Second) + "" + (DateTime.Now.Millisecond);
                //-- agregar la extension al archivo                
                nuevoArchivo += "." + temp[temp.Length - 1];
                System.IO.File.Copy(archivoOriginal,(directorioDestino + nuevoArchivo), true);
            }
            catch (Exception ex)
            {
                herramientas.MessageException.show(ex);
                return string.Empty;
            }
            return nuevoArchivo;
        }
        /// <summary>
        /// <para>Crear un nuevo un archivo APARTIR DE UN ARCHIVO EXISTENTE (se selecciona atraves de un asistente) en un directorio.<br/> Al nuevo archivo se le coloca un nombre compuesto por un numero aleatorio y la fechaHora de creacion.</para>
        /// <para>El principal uso de este metodo es subir archivos a la carpeta de archivos de soporte.</para>
        /// </summary>
        /// <param name="directorioDestino">Directorio en el cual se creara el nuevo archivo.</param>
        /// <returns>
        /// <para>Nombre completo del nuevo archivo (incluye la extension del nuevo archivo)</para>
        /// <para>En caso de que la operacion no se realice de forma correcta retorna un string vacio (string.Empty)</para>
        /// </returns>
        public static string newFile(string directorioDestino)
        {
            string nuevoArchivo = "";
            try
            {
                //-- buscar el archivo que se va a copiar
                OpenFileDialog openFileDialog = new OpenFileDialog();
                openFileDialog.RestoreDirectory = true;
                if (openFileDialog.ShowDialog() != DialogResult.OK)
                {
                    return string.Empty;
                }

                //--definir la extension del nuevo archivo.
                string[] temp = openFileDialog.FileName.Split('.');
                //-- definir el nombre del nuevo archivo (UNICO)
                nuevoArchivo = (new Random().Next(0, 1000)) + "" + (DateTime.Now.Year) + "" + (DateTime.Now.Month) + "" + (DateTime.Now.Day) + "" + (DateTime.Now.Hour) + "" + (DateTime.Now.Minute) + "" + (DateTime.Now.Second) + "" + (DateTime.Now.Millisecond);
                //-- agregar la extension al archivo                
                nuevoArchivo +="."+ temp[temp.Length - 1];

                System.IO.File.Copy(openFileDialog.FileName, directorioDestino + nuevoArchivo, true);
            }
            catch (Exception ex)
            {
                herramientas.MessageException.show(ex);
                return string.Empty;
            }
            return nuevoArchivo;
        }
        
        
        /// <summary>
        /// Eliminar achivos
        /// </summary>
        /// <param name="archivo">ruta completa del archivo que se desea copiar</param>
        /// <returns></returns>
        public static bool deleteFile(string archivo)
        {
            try
            {
                System.IO.File.Delete(archivo);
                return true;
            }
            catch (Exception ex)
            {
                herramientas.MessageException.show(ex);
                return false;
            }
        }
                                         
        /// <summary>
        /// Mover achivos
        /// </summary>
        /// <param name="archivoOriginal">ruta completa del archivo que se desea mover</param>
        /// <returns></returns>
        public static bool moveFile(string archivoOriginal)
        {
            try
            {
                //--definir la extension del nuevo archivo.
                string[] temp = archivoOriginal.Split('.');
                //MessageBox.Show(temp[temp.Length-1]);

                //--crear el nuevo archivo
                SaveFileDialog saveFileDialog = new SaveFileDialog();
                saveFileDialog.Filter = "(*." + temp[temp.Length - 1].ToUpper() + ")|*." + temp[temp.Length - 1].ToLower();//"txt files (*.txt)|*.txt|All files (*.*)|*.*";
                saveFileDialog.FilterIndex = 0;
                saveFileDialog.RestoreDirectory = true;
                if (saveFileDialog.ShowDialog() != DialogResult.OK)
                {
                    return false;
                }
                System.IO.File.Move(archivoOriginal, saveFileDialog.FileName);
                return true;
            }
            catch (Exception ex)
            {
                herramientas.MessageException.show(ex);
                return false;
            }
        }
        /// <summary>
        /// Mover achivos
        /// </summary>
        /// <param name="archivoOriginal">ruta completa del archivo que se desea mover</param>
        /// <param name="archivoDestino">ruta completa del archivo que se creara apartir del archivoOriginal</param>
        /// <returns></returns>
        public static bool moveFile(string archivoOriginal, string archivoDestino)
        {
            try
            {
                System.IO.File.Move(archivoOriginal, archivoDestino);
                return true;
            }
            catch (Exception ex)
            {
                herramientas.MessageException.show(ex);
                return false;
            }
        }
                
        /// <summary>
        /// Copiar achivos
        /// </summary>
        /// <param name="archivoOriginal">ruta completa del archivo que se desea copiar</param>
        /// <returns></returns>
        public static bool copyFile(string archivoOriginal)
        {
            try
            {                
                //--definir la extension del nuevo archivo.
                string[] temp = archivoOriginal.Split('.');
                //MessageBox.Show(temp[temp.Length-1]);

                //--crear el nuevo archivo
                SaveFileDialog saveFileDialog = new SaveFileDialog();
                saveFileDialog.Filter = "(*." + temp[temp.Length - 1].ToUpper() + ")|*." + temp[temp.Length - 1].ToLower();//"txt files (*.txt)|*.txt|All files (*.*)|*.*";
                saveFileDialog.FilterIndex = 0;
                saveFileDialog.RestoreDirectory = true;
                if (saveFileDialog.ShowDialog() != DialogResult.OK)
                {
                    return false;
                }
                System.IO.File.Copy(archivoOriginal, saveFileDialog.FileName, true);
                return true;
            }
            catch (Exception ex)
            {
                herramientas.MessageException.show(ex);
                return false;
            }
        }        
        /// <summary>
        /// Copiar achivos
        /// </summary>
        /// <param name="archivoOriginal">ruta completa del archivo que se desea copiar</param>
        /// <param name="archivoDestino">ruta completa del archivo que se creara apartir del archivoOriginal</param>
        /// <returns></returns>
        public static bool copyFile( string archivoOriginal, string archivoDestino)
        {
            try
            {
                System.IO.File.Copy(archivoOriginal, archivoDestino, true);                
                return true;
            }
            catch (Exception ex)
            {
                herramientas.MessageException.show(ex);
                return false;
            }
        }
        
        /// <summary>
        /// Comvertir archivos fisicos en Byte
        /// </summary>
        /// <param name="rutaArchivo">Ruta completa del archivo a digitalizar</param>
        /// <returns>Archivo original en Bytes</returns>
        public static byte[] fileToByte(string rutaArchivo)
        {
            try
            {
                String strBLOBFilePath = @"" + rutaArchivo;
                FileStream fsBLOBFile = new FileStream(strBLOBFilePath, FileMode.Open, FileAccess.Read);
                byte[] bytBLOBData = new byte[fsBLOBFile.Length];
                fsBLOBFile.Read(bytBLOBData, 0, bytBLOBData.Length);               
                fsBLOBFile.Close();
                return bytBLOBData;
            }
            catch (Exception ex)
            {
                herramientas.MessageException.show(ex);
                return null;
            } 
        }
        /// <summary>
        /// Comvertir archivos fisicos en Byte
        /// </summary>
        /// <returns>Archivo original en Bytes</returns>
        public static byte[] fileToByte()
        {
            try
            {
                OpenFileDialog saveFileDialog = new OpenFileDialog();
                saveFileDialog.Filter = "(*.PDF)|*.pdf|(*.PNG)|*.png|(*.JPG)|*.jpg";//"txt files (*.txt)|*.txt|All files (*.*)|*.*";
                saveFileDialog.FilterIndex = 0;
                saveFileDialog.Multiselect = false;
                saveFileDialog.RestoreDirectory = true;
                if (saveFileDialog.ShowDialog() != DialogResult.OK)
                {
                    return null;
                }
                String strBLOBFilePath = @"" + saveFileDialog.FileName;
                FileStream fsBLOBFile = new FileStream(strBLOBFilePath, FileMode.Open, FileAccess.Read);
                byte[] bytBLOBData = new byte[fsBLOBFile.Length];
                fsBLOBFile.Read(bytBLOBData, 0, bytBLOBData.Length);
                fsBLOBFile.Close();
                return bytBLOBData;
            }
            catch (Exception ex)
            {
                herramientas.MessageException.show(ex);
                return null;
            } 
        }

        /// <summary>
        /// Convertir archivos fisicos en un objeto de tipo imagen. su principal uso es la conversion de archivos
        /// de imagen en disco (JPG, PNG, etc) en un formato que puede ser representado por un control de tipo PicturyBox
        /// </summary>
        /// <param name="rutaArchivo">Ruta completa del archivo a digitalizar</param>
        /// <returns>Archivo original en formato Image</returns>
        public static Image fileToImage(string rutaArchivo)
        {
            try
            {
                String strBLOBFilePath = @"" + rutaArchivo;
                FileStream fsBLOBFile = new FileStream(strBLOBFilePath, FileMode.Open, FileAccess.Read);
                Image image = Image.FromStream(fsBLOBFile);
                fsBLOBFile.Close();
                return image;
            }
            catch (Exception ex)
            {
                herramientas.MessageException.show(ex);
                return null;
            } 
        }
        /// <summary>
        /// Convertir archivos fisicos en un objeto de tipo imagen. su principal uso es la conversion de archivos
        /// de imagen en disco (JPG, PNG, etc) en un formato que puede ser representado por un control de tipo PicturyBox
        /// </summary>
        /// <returns>Archivo original en formato Image</returns>
        public static Image fileToImage()
        {
            try
            {                 
                OpenFileDialog saveFileDialog = new OpenFileDialog();
                saveFileDialog.Filter = "(*.png)|*.png|(*.jpg)|*.jpg";//"txt files (*.txt)|*.txt|All files (*.*)|*.*";
                saveFileDialog.FilterIndex = 0;
                saveFileDialog.Multiselect = false;
                saveFileDialog.RestoreDirectory = true;
                if (saveFileDialog.ShowDialog() != DialogResult.OK)
                {
                    return null;
                }
                String strBLOBFilePath = @"" + saveFileDialog.FileName;
                FileStream fsBLOBFile = new FileStream(strBLOBFilePath, FileMode.Open, FileAccess.Read);
                Image image =Image.FromStream(fsBLOBFile);
                fsBLOBFile.Close();
                return image;
            }
            catch (Exception ex)
            {
                herramientas.MessageException.show(ex);
                return null;
            } 
        }

        /// <summary>
        /// Convertir una cadena de Bytes en un archivo fisico de solo lectura (PDF)
        /// </summary>
        /// <param name="bytes">Cadena de Bytes a partir de la cual se desea generar el archivo PDF</param>
        /// <param name="rutaArchivoPDF">Ruta absoluta del nuevo archivo</param>
        /// <returns></returns>
        public static bool byteToPDF(object bytes, string rutaArchivoPDF)
        {
            try
            {
                
                String strBLOBFilePath = @"" + rutaArchivoPDF;
                FileStream fsBLOBFile = new FileStream(strBLOBFilePath, FileMode.Create, FileAccess.Write);
                byte[] bytBLOBData = (byte[])bytes;
                fsBLOBFile.Write(bytBLOBData, 0, bytBLOBData.Length);
                fsBLOBFile.Close();
                return true;
            }
            catch (Exception ex)
            {
                herramientas.MessageException.show(ex);
                return false;
            }
        }
        /// <summary>
        /// Convertir una cadena de Bytes en un archivo fisico de solo lectura (PDF)
        /// </summary>
        /// <param name="bytes">Cadena de Bytes a partir de la cual se desea generar el archivo PDF</param>
        /// <returns></returns>
        public static bool byteToPDF(object bytes)
        {
            try
            {
                SaveFileDialog saveFileDialog = new SaveFileDialog();
                saveFileDialog.Filter = "(*.PDF)|*.pdf";//"txt files (*.txt)|*.txt|All files (*.*)|*.*";
                saveFileDialog.FilterIndex = 0;
                saveFileDialog.RestoreDirectory = true;
                if (saveFileDialog.ShowDialog() != DialogResult.OK)
                {
                    return false;
                }
                String strBLOBFilePath = @"" + saveFileDialog.FileName;
                FileStream fsBLOBFile = new FileStream(strBLOBFilePath, FileMode.Create, FileAccess.Write);
                byte[] bytBLOBData = (byte[])bytes;
                fsBLOBFile.Write(bytBLOBData, 0, bytBLOBData.Length);
                fsBLOBFile.Close();
                return true;
            }
            catch (Exception ex)
            {
                herramientas.MessageException.show(ex);
                return false;
            }
        }
        /// <summary>
        /// Convertir una cadena de Bytes en un archivo fisico de solo lectura (PDF)
        /// </summary>
        /// <param name="bytes">Cadena de Bytes a partir de la cual se desea generar el archivo PDF</param>
        /// <param name="rutaArchivoPDF">Ruta absoluta del nuevo archivo</param>
        /// <returns></returns>
        public static bool byteToPDF(byte[] bytes, string rutaArchivoPDF)
        {
            try
            {
                String strBLOBFilePath = @"" + rutaArchivoPDF;
                FileStream fsBLOBFile = new FileStream(strBLOBFilePath, FileMode.Create, FileAccess.Write);
                //byte[] bytBLOBData = new byte[fsBLOBFile.Length];
                fsBLOBFile.Write(bytes, 0, bytes.Length);
                fsBLOBFile.Close();
                return true;
            }
            catch (Exception ex)
            {
                herramientas.MessageException.show(ex);
                return false;
            } 
        }
        /// <summary>
        /// Convertir una cadena de Bytes en un archivo fisico de solo lectura (PDF)
        /// </summary>
        /// <param name="bytes">Cadena de Bytes a partir de la cual se desea generar el archivo PDF</param>
        /// <returns></returns>
        public static bool byteToPDF(byte[] bytes)
        {
            try
            {
                SaveFileDialog saveFileDialog = new SaveFileDialog();
                saveFileDialog.Filter = "(*.PDF)|*.pdf";//"txt files (*.txt)|*.txt|All files (*.*)|*.*";
                saveFileDialog.FilterIndex = 0;
                saveFileDialog.RestoreDirectory = true;
                if (saveFileDialog.ShowDialog() != DialogResult.OK)
                {
                    return false;
                }
                String strBLOBFilePath = @"" + saveFileDialog.FileName;
                FileStream fsBLOBFile = new FileStream(strBLOBFilePath, FileMode.Create, FileAccess.Write);
                fsBLOBFile.Write(bytes, 0, bytes.Length);
                fsBLOBFile.Close();

                return true;
            }
            catch (Exception ex)
            {
                herramientas.MessageException.show(ex);
                return false;                
            }            
        }
        
    }
}
